home *** CD-ROM | disk | FTP | other *** search
/ PC World 2007 March / PCWorld_2007-03_cd.bin / domacnost a kancelar / scribus / scribus-1.3.3.7-win32-install.exe / lib / logging / handlers.py < prev   
Text File  |  2005-09-12  |  38KB  |  976 lines
  1. # Copyright 2001-2005 by Vinay Sajip. All Rights Reserved.
  2. #
  3. # Permission to use, copy, modify, and distribute this software and its
  4. # documentation for any purpose and without fee is hereby granted,
  5. # provided that the above copyright notice appear in all copies and that
  6. # both that copyright notice and this permission notice appear in
  7. # supporting documentation, and that the name of Vinay Sajip
  8. # not be used in advertising or publicity pertaining to distribution
  9. # of the software without specific, written prior permission.
  10. # VINAY SAJIP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  11. # ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL
  12. # VINAY SAJIP BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  13. # ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  14. # IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  15. # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16.  
  17. """
  18. Additional handlers for the logging package for Python. The core package is
  19. based on PEP 282 and comments thereto in comp.lang.python, and influenced by
  20. Apache's log4j system.
  21.  
  22. Should work under Python versions >= 1.5.2, except that source line
  23. information is not available unless 'sys._getframe()' is.
  24.  
  25. Copyright (C) 2001-2004 Vinay Sajip. All Rights Reserved.
  26.  
  27. To use, simply 'import logging' and log away!
  28. """
  29.  
  30. import sys, logging, socket, types, os, string, cPickle, struct, time, glob
  31.  
  32. try:
  33.     import codecs
  34. except ImportError:
  35.     codecs = None
  36.  
  37. #
  38. # Some constants...
  39. #
  40.  
  41. DEFAULT_TCP_LOGGING_PORT    = 9020
  42. DEFAULT_UDP_LOGGING_PORT    = 9021
  43. DEFAULT_HTTP_LOGGING_PORT   = 9022
  44. DEFAULT_SOAP_LOGGING_PORT   = 9023
  45. SYSLOG_UDP_PORT             = 514
  46.  
  47. class BaseRotatingHandler(logging.FileHandler):
  48.     """
  49.     Base class for handlers that rotate log files at a certain point.
  50.     Not meant to be instantiated directly.  Instead, use RotatingFileHandler
  51.     or TimedRotatingFileHandler.
  52.     """
  53.     def __init__(self, filename, mode, encoding=None):
  54.         """
  55.         Use the specified filename for streamed logging
  56.         """
  57.         if codecs is None:
  58.             encoding = None
  59.         logging.FileHandler.__init__(self, filename, mode, encoding)
  60.         self.mode = mode
  61.         self.encoding = encoding
  62.  
  63.     def emit(self, record):
  64.         """
  65.         Emit a record.
  66.  
  67.         Output the record to the file, catering for rollover as described
  68.         in doRollover().
  69.         """
  70.         try:
  71.             if self.shouldRollover(record):
  72.                 self.doRollover()
  73.             logging.FileHandler.emit(self, record)
  74.         except:
  75.             self.handleError(record)
  76.  
  77. class RotatingFileHandler(BaseRotatingHandler):
  78.     """
  79.     Handler for logging to a set of files, which switches from one file
  80.     to the next when the current file reaches a certain size.
  81.     """
  82.     def __init__(self, filename, mode='a', maxBytes=0, backupCount=0, encoding=None):
  83.         """
  84.         Open the specified file and use it as the stream for logging.
  85.  
  86.         By default, the file grows indefinitely. You can specify particular
  87.         values of maxBytes and backupCount to allow the file to rollover at
  88.         a predetermined size.
  89.  
  90.         Rollover occurs whenever the current log file is nearly maxBytes in
  91.         length. If backupCount is >= 1, the system will successively create
  92.         new files with the same pathname as the base file, but with extensions
  93.         ".1", ".2" etc. appended to it. For example, with a backupCount of 5
  94.         and a base file name of "app.log", you would get "app.log",
  95.         "app.log.1", "app.log.2", ... through to "app.log.5". The file being
  96.         written to is always "app.log" - when it gets filled up, it is closed
  97.         and renamed to "app.log.1", and if files "app.log.1", "app.log.2" etc.
  98.         exist, then they are renamed to "app.log.2", "app.log.3" etc.
  99.         respectively.
  100.  
  101.         If maxBytes is zero, rollover never occurs.
  102.         """
  103.         if maxBytes > 0:
  104.             mode = 'a' # doesn't make sense otherwise!
  105.         BaseRotatingHandler.__init__(self, filename, mode, encoding)
  106.         self.maxBytes = maxBytes
  107.         self.backupCount = backupCount
  108.  
  109.     def doRollover(self):
  110.         """
  111.         Do a rollover, as described in __init__().
  112.         """
  113.  
  114.         self.stream.close()
  115.         if self.backupCount > 0:
  116.             for i in range(self.backupCount - 1, 0, -1):
  117.                 sfn = "%s.%d" % (self.baseFilename, i)
  118.                 dfn = "%s.%d" % (self.baseFilename, i + 1)
  119.                 if os.path.exists(sfn):
  120.                     #print "%s -> %s" % (sfn, dfn)
  121.                     if os.path.exists(dfn):
  122.                         os.remove(dfn)
  123.                     os.rename(sfn, dfn)
  124.             dfn = self.baseFilename + ".1"
  125.             if os.path.exists(dfn):
  126.                 os.remove(dfn)
  127.             os.rename(self.baseFilename, dfn)
  128.             #print "%s -> %s" % (self.baseFilename, dfn)
  129.         if self.encoding:
  130.             self.stream = codecs.open(self.baseFilename, 'w', self.encoding)
  131.         else:
  132.             self.stream = open(self.baseFilename, 'w')
  133.  
  134.     def shouldRollover(self, record):
  135.         """
  136.         Determine if rollover should occur.
  137.  
  138.         Basically, see if the supplied record would cause the file to exceed
  139.         the size limit we have.
  140.         """
  141.         if self.maxBytes > 0:                   # are we rolling over?
  142.             msg = "%s\n" % self.format(record)
  143.             self.stream.seek(0, 2)  #due to non-posix-compliant Windows feature
  144.             if self.stream.tell() + len(msg) >= self.maxBytes:
  145.                 return 1
  146.         return 0
  147.  
  148. class TimedRotatingFileHandler(BaseRotatingHandler):
  149.     """
  150.     Handler for logging to a file, rotating the log file at certain timed
  151.     intervals.
  152.  
  153.     If backupCount is > 0, when rollover is done, no more than backupCount
  154.     files are kept - the oldest ones are deleted.
  155.     """
  156.     def __init__(self, filename, when='h', interval=1, backupCount=0, encoding=None):
  157.         BaseRotatingHandler.__init__(self, filename, 'a', encoding)
  158.         self.when = string.upper(when)
  159.         self.backupCount = backupCount
  160.         # Calculate the real rollover interval, which is just the number of
  161.         # seconds between rollovers.  Also set the filename suffix used when
  162.         # a rollover occurs.  Current 'when' events supported:
  163.         # S - Seconds
  164.         # M - Minutes
  165.         # H - Hours
  166.         # D - Days
  167.         # midnight - roll over at midnight
  168.         # W{0-6} - roll over on a certain day; 0 - Monday
  169.         #
  170.         # Case of the 'when' specifier is not important; lower or upper case
  171.         # will work.
  172.         currentTime = int(time.time())
  173.         if self.when == 'S':
  174.             self.interval = 1 # one second
  175.             self.suffix = "%Y-%m-%d_%H-%M-%S"
  176.         elif self.when == 'M':
  177.             self.interval = 60 # one minute
  178.             self.suffix = "%Y-%m-%d_%H-%M"
  179.         elif self.when == 'H':
  180.             self.interval = 60 * 60 # one hour
  181.             self.suffix = "%Y-%m-%d_%H"
  182.         elif self.when == 'D' or self.when == 'MIDNIGHT':
  183.             self.interval = 60 * 60 * 24 # one day
  184.             self.suffix = "%Y-%m-%d"
  185.         elif self.when.startswith('W'):
  186.             self.interval = 60 * 60 * 24 * 7 # one week
  187.             if len(self.when) != 2:
  188.                 raise ValueError("You must specify a day for weekly rollover from 0 to 6 (0 is Monday): %s" % self.when)
  189.             if self.when[1] < '0' or self.when[1] > '6':
  190.                 raise ValueError("Invalid day specified for weekly rollover: %s" % self.when)
  191.             self.dayOfWeek = int(self.when[1])
  192.             self.suffix = "%Y-%m-%d"
  193.         else:
  194.             raise ValueError("Invalid rollover interval specified: %s" % self.when)
  195.  
  196.         self.interval = self.interval * interval # multiply by units requested
  197.         self.rolloverAt = currentTime + self.interval
  198.  
  199.         # If we are rolling over at midnight or weekly, then the interval is already known.
  200.         # What we need to figure out is WHEN the next interval is.  In other words,
  201.         # if you are rolling over at midnight, then your base interval is 1 day,
  202.         # but you want to start that one day clock at midnight, not now.  So, we
  203.         # have to fudge the rolloverAt value in order to trigger the first rollover
  204.         # at the right time.  After that, the regular interval will take care of
  205.         # the rest.  Note that this code doesn't care about leap seconds. :)
  206.         if self.when == 'MIDNIGHT' or self.when.startswith('W'):
  207.             # This could be done with less code, but I wanted it to be clear
  208.             t = time.localtime(currentTime)
  209.             currentHour = t[3]
  210.             currentMinute = t[4]
  211.             currentSecond = t[5]
  212.             # r is the number of seconds left between now and midnight
  213.             r = (24 - currentHour) * 60 * 60 # number of hours in seconds
  214.             r = r + (59 - currentMinute) * 60 # plus the number of minutes (in secs)
  215.             r = r + (59 - currentSecond) # plus the number of seconds
  216.             self.rolloverAt = currentTime + r
  217.             # If we are rolling over on a certain day, add in the number of days until
  218.             # the next rollover, but offset by 1 since we just calculated the time
  219.             # until the next day starts.  There are three cases:
  220.             # Case 1) The day to rollover is today; in this case, do nothing
  221.             # Case 2) The day to rollover is further in the interval (i.e., today is
  222.             #         day 2 (Wednesday) and rollover is on day 6 (Sunday).  Days to
  223.             #         next rollover is simply 6 - 2 - 1, or 3.
  224.             # Case 3) The day to rollover is behind us in the interval (i.e., today
  225.             #         is day 5 (Saturday) and rollover is on day 3 (Thursday).
  226.             #         Days to rollover is 6 - 5 + 3, or 4.  In this case, it's the
  227.             #         number of days left in the current week (1) plus the number
  228.             #         of days in the next week until the rollover day (3).
  229.             if when.startswith('W'):
  230.                 day = t[6] # 0 is Monday
  231.                 if day > self.dayOfWeek:
  232.                     daysToWait = (day - self.dayOfWeek) - 1
  233.                     self.rolloverAt = self.rolloverAt + (daysToWait * (60 * 60 * 24))
  234.                 if day < self.dayOfWeek:
  235.                     daysToWait = (6 - self.dayOfWeek) + day
  236.                     self.rolloverAt = self.rolloverAt + (daysToWait * (60 * 60 * 24))
  237.  
  238.         #print "Will rollover at %d, %d seconds from now" % (self.rolloverAt, self.rolloverAt - currentTime)
  239.  
  240.     def shouldRollover(self, record):
  241.         """
  242.         Determine if rollover should occur
  243.  
  244.         record is not used, as we are just comparing times, but it is needed so
  245.         the method siguratures are the same
  246.         """
  247.         t = int(time.time())
  248.         if t >= self.rolloverAt:
  249.             return 1
  250.         #print "No need to rollover: %d, %d" % (t, self.rolloverAt)
  251.         return 0
  252.  
  253.     def doRollover(self):
  254.         """
  255.         do a rollover; in this case, a date/time stamp is appended to the filename
  256.         when the rollover happens.  However, you want the file to be named for the
  257.         start of the interval, not the current time.  If there is a backup count,
  258.         then we have to get a list of matching filenames, sort them and remove
  259.         the one with the oldest suffix.
  260.         """
  261.         self.stream.close()
  262.         # get the time that this sequence started at and make it a TimeTuple
  263.         t = self.rolloverAt - self.interval
  264.         timeTuple = time.localtime(t)
  265.         dfn = self.baseFilename + "." + time.strftime(self.suffix, timeTuple)
  266.         if os.path.exists(dfn):
  267.             os.remove(dfn)
  268.         os.rename(self.baseFilename, dfn)
  269.         if self.backupCount > 0:
  270.             # find the oldest log file and delete it
  271.             s = glob.glob(self.baseFilename + ".20*")
  272.             if len(s) > self.backupCount:
  273.                 s.sort()
  274.                 os.remove(s[0])
  275.         #print "%s -> %s" % (self.baseFilename, dfn)
  276.         if self.encoding:
  277.             self.stream = codecs.open(self.baseFilename, 'w', self.encoding)
  278.         else:
  279.             self.stream = open(self.baseFilename, 'w')
  280.         self.rolloverAt = int(time.time()) + self.interval
  281.  
  282. class SocketHandler(logging.Handler):
  283.     """
  284.     A handler class which writes logging records, in pickle format, to
  285.     a streaming socket. The socket is kept open across logging calls.
  286.     If the peer resets it, an attempt is made to reconnect on the next call.
  287.     The pickle which is sent is that of the LogRecord's attribute dictionary
  288.     (__dict__), so that the receiver does not need to have the logging module
  289.     installed in order to process the logging event.
  290.  
  291.     To unpickle the record at the receiving end into a LogRecord, use the
  292.     makeLogRecord function.
  293.     """
  294.  
  295.     def __init__(self, host, port):
  296.         """
  297.         Initializes the handler with a specific host address and port.
  298.  
  299.         The attribute 'closeOnError' is set to 1 - which means that if
  300.         a socket error occurs, the socket is silently closed and then
  301.         reopened on the next logging call.
  302.         """
  303.         logging.Handler.__init__(self)
  304.         self.host = host
  305.         self.port = port
  306.         self.sock = None
  307.         self.closeOnError = 0
  308.         self.retryTime = None
  309.         #
  310.         # Exponential backoff parameters.
  311.         #
  312.         self.retryStart = 1.0
  313.         self.retryMax = 30.0
  314.         self.retryFactor = 2.0
  315.  
  316.     def makeSocket(self):
  317.         """
  318.         A factory method which allows subclasses to define the precise
  319.         type of socket they want.
  320.         """
  321.         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  322.         s.connect((self.host, self.port))
  323.         return s
  324.  
  325.     def createSocket(self):
  326.         """
  327.         Try to create a socket, using an exponential backoff with
  328.         a max retry time. Thanks to Robert Olson for the original patch
  329.         (SF #815911) which has been slightly refactored.
  330.         """
  331.         now = time.time()
  332.         # Either retryTime is None, in which case this
  333.         # is the first time back after a disconnect, or
  334.         # we've waited long enough.
  335.         if self.retryTime is None:
  336.             attempt = 1
  337.         else:
  338.             attempt = (now >= self.retryTime)
  339.         if attempt:
  340.             try:
  341.                 self.sock = self.makeSocket()
  342.                 self.retryTime = None # next time, no delay before trying
  343.             except:
  344.                 #Creation failed, so set the retry time and return.
  345.                 if self.retryTime is None:
  346.                     self.retryPeriod = self.retryStart
  347.                 else:
  348.                     self.retryPeriod = self.retryPeriod * self.retryFactor
  349.                     if self.retryPeriod > self.retryMax:
  350.                         self.retryPeriod = self.retryMax
  351.                 self.retryTime = now + self.retryPeriod
  352.  
  353.     def send(self, s):
  354.         """
  355.         Send a pickled string to the socket.
  356.  
  357.         This function allows for partial sends which can happen when the
  358.         network is busy.
  359.         """
  360.         if self.sock is None:
  361.             self.createSocket()
  362.         #self.sock can be None either because we haven't reached the retry
  363.         #time yet, or because we have reached the retry time and retried,
  364.         #but are still unable to connect.
  365.         if self.sock:
  366.             try:
  367.                 if hasattr(self.sock, "sendall"):
  368.                     self.sock.sendall(s)
  369.                 else:
  370.                     sentsofar = 0
  371.                     left = len(s)
  372.                     while left > 0:
  373.                         sent = self.sock.send(s[sentsofar:])
  374.                         sentsofar = sentsofar + sent
  375.                         left = left - sent
  376.             except socket.error:
  377.                 self.sock.close()
  378.                 self.sock = None  # so we can call createSocket next time
  379.  
  380.     def makePickle(self, record):
  381.         """
  382.         Pickles the record in binary format with a length prefix, and
  383.         returns it ready for transmission across the socket.
  384.         """
  385.         ei = record.exc_info
  386.         if ei:
  387.             dummy = self.format(record) # just to get traceback text into record.exc_text
  388.             record.exc_info = None  # to avoid Unpickleable error
  389.         s = cPickle.dumps(record.__dict__, 1)
  390.         if ei:
  391.             record.exc_info = ei  # for next handler
  392.         slen = struct.pack(">L", len(s))
  393.         return slen + s
  394.  
  395.     def handleError(self, record):
  396.         """
  397.         Handle an error during logging.
  398.  
  399.         An error has occurred during logging. Most likely cause -
  400.         connection lost. Close the socket so that we can retry on the
  401.         next event.
  402.         """
  403.         if self.closeOnError and self.sock:
  404.             self.sock.close()
  405.             self.sock = None        #try to reconnect next time
  406.         else:
  407.             logging.Handler.handleError(self, record)
  408.  
  409.     def emit(self, record):
  410.         """
  411.         Emit a record.
  412.  
  413.         Pickles the record and writes it to the socket in binary format.
  414.         If there is an error with the socket, silently drop the packet.
  415.         If there was a problem with the socket, re-establishes the
  416.         socket.
  417.         """
  418.         try:
  419.             s = self.makePickle(record)
  420.             self.send(s)
  421.         except:
  422.             self.handleError(record)
  423.  
  424.     def close(self):
  425.         """
  426.         Closes the socket.
  427.         """
  428.         if self.sock:
  429.             self.sock.close()
  430.             self.sock = None
  431.         logging.Handler.close(self)
  432.  
  433. class DatagramHandler(SocketHandler):
  434.     """
  435.     A handler class which writes logging records, in pickle format, to
  436.     a datagram socket.  The pickle which is sent is that of the LogRecord's
  437.     attribute dictionary (__dict__), so that the receiver does not need to
  438.     have the logging module installed in order to process the logging event.
  439.  
  440.     To unpickle the record at the receiving end into a LogRecord, use the
  441.     makeLogRecord function.
  442.  
  443.     """
  444.     def __init__(self, host, port):
  445.         """
  446.         Initializes the handler with a specific host address and port.
  447.         """
  448.         SocketHandler.__init__(self, host, port)
  449.         self.closeOnError = 0
  450.  
  451.     def makeSocket(self):
  452.         """
  453.         The factory method of SocketHandler is here overridden to create
  454.         a UDP socket (SOCK_DGRAM).
  455.         """
  456.         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  457.         return s
  458.  
  459.     def send(self, s):
  460.         """
  461.         Send a pickled string to a socket.
  462.  
  463.         This function no longer allows for partial sends which can happen
  464.         when the network is busy - UDP does not guarantee delivery and
  465.         can deliver packets out of sequence.
  466.         """
  467.         if self.sock is None:
  468.             self.createSocket()
  469.         self.sock.sendto(s, (self.host, self.port))
  470.  
  471. class SysLogHandler(logging.Handler):
  472.     """
  473.     A handler class which sends formatted logging records to a syslog
  474.     server. Based on Sam Rushing's syslog module:
  475.     http://www.nightmare.com/squirl/python-ext/misc/syslog.py
  476.     Contributed by Nicolas Untz (after which minor refactoring changes
  477.     have been made).
  478.     """
  479.  
  480.     # from <linux/sys/syslog.h>:
  481.     # ======================================================================
  482.     # priorities/facilities are encoded into a single 32-bit quantity, where
  483.     # the bottom 3 bits are the priority (0-7) and the top 28 bits are the
  484.     # facility (0-big number). Both the priorities and the facilities map
  485.     # roughly one-to-one to strings in the syslogd(8) source code.  This
  486.     # mapping is included in this file.
  487.     #
  488.     # priorities (these are ordered)
  489.  
  490.     LOG_EMERG     = 0       #  system is unusable
  491.     LOG_ALERT     = 1       #  action must be taken immediately
  492.     LOG_CRIT      = 2       #  critical conditions
  493.     LOG_ERR       = 3       #  error conditions
  494.     LOG_WARNING   = 4       #  warning conditions
  495.     LOG_NOTICE    = 5       #  normal but significant condition
  496.     LOG_INFO      = 6       #  informational
  497.     LOG_DEBUG     = 7       #  debug-level messages
  498.  
  499.     #  facility codes
  500.     LOG_KERN      = 0       #  kernel messages
  501.     LOG_USER      = 1       #  random user-level messages
  502.     LOG_MAIL      = 2       #  mail system
  503.     LOG_DAEMON    = 3       #  system daemons
  504.     LOG_AUTH      = 4       #  security/authorization messages
  505.     LOG_SYSLOG    = 5       #  messages generated internally by syslogd
  506.     LOG_LPR       = 6       #  line printer subsystem
  507.     LOG_NEWS      = 7       #  network news subsystem
  508.     LOG_UUCP      = 8       #  UUCP subsystem
  509.     LOG_CRON      = 9       #  clock daemon
  510.     LOG_AUTHPRIV  = 10  #  security/authorization messages (private)
  511.  
  512.     #  other codes through 15 reserved for system use
  513.     LOG_LOCAL0    = 16      #  reserved for local use
  514.     LOG_LOCAL1    = 17      #  reserved for local use
  515.     LOG_LOCAL2    = 18      #  reserved for local use
  516.     LOG_LOCAL3    = 19      #  reserved for local use
  517.     LOG_LOCAL4    = 20      #  reserved for local use
  518.     LOG_LOCAL5    = 21      #  reserved for local use
  519.     LOG_LOCAL6    = 22      #  reserved for local use
  520.     LOG_LOCAL7    = 23      #  reserved for local use
  521.  
  522.     priority_names = {
  523.         "alert":    LOG_ALERT,
  524.         "crit":     LOG_CRIT,
  525.         "critical": LOG_CRIT,
  526.         "debug":    LOG_DEBUG,
  527.         "emerg":    LOG_EMERG,
  528.         "err":      LOG_ERR,
  529.         "error":    LOG_ERR,        #  DEPRECATED
  530.         "info":     LOG_INFO,
  531.         "notice":   LOG_NOTICE,
  532.         "panic":    LOG_EMERG,      #  DEPRECATED
  533.         "warn":     LOG_WARNING,    #  DEPRECATED
  534.         "warning":  LOG_WARNING,
  535.         }
  536.  
  537.     facility_names = {
  538.         "auth":     LOG_AUTH,
  539.         "authpriv": LOG_AUTHPRIV,
  540.         "cron":     LOG_CRON,
  541.         "daemon":   LOG_DAEMON,
  542.         "kern":     LOG_KERN,
  543.         "lpr":      LOG_LPR,
  544.         "mail":     LOG_MAIL,
  545.         "news":     LOG_NEWS,
  546.         "security": LOG_AUTH,       #  DEPRECATED
  547.         "syslog":   LOG_SYSLOG,
  548.         "user":     LOG_USER,
  549.         "uucp":     LOG_UUCP,
  550.         "local0":   LOG_LOCAL0,
  551.         "local1":   LOG_LOCAL1,
  552.         "local2":   LOG_LOCAL2,
  553.         "local3":   LOG_LOCAL3,
  554.         "local4":   LOG_LOCAL4,
  555.         "local5":   LOG_LOCAL5,
  556.         "local6":   LOG_LOCAL6,
  557.         "local7":   LOG_LOCAL7,
  558.         }
  559.  
  560.     def __init__(self, address=('localhost', SYSLOG_UDP_PORT), facility=LOG_USER):
  561.         """
  562.         Initialize a handler.
  563.  
  564.         If address is specified as a string, UNIX socket is used.
  565.         If facility is not specified, LOG_USER is used.
  566.         """
  567.         logging.Handler.__init__(self)
  568.  
  569.         self.address = address
  570.         self.facility = facility
  571.         if type(address) == types.StringType:
  572.             self._connect_unixsocket(address)
  573.             self.unixsocket = 1
  574.         else:
  575.             self.socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  576.             self.unixsocket = 0
  577.  
  578.         self.formatter = None
  579.  
  580.     def _connect_unixsocket(self, address):
  581.         self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
  582.         # syslog may require either DGRAM or STREAM sockets
  583.         try:
  584.             self.socket.connect(address)
  585.         except socket.error:
  586.             self.socket.close()
  587.             self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
  588.         self.socket.connect(address)
  589.  
  590.     # curious: when talking to the unix-domain '/dev/log' socket, a
  591.     #   zero-terminator seems to be required.  this string is placed
  592.     #   into a class variable so that it can be overridden if
  593.     #   necessary.
  594.     log_format_string = '<%d>%s\000'
  595.  
  596.     def encodePriority (self, facility, priority):
  597.         """
  598.         Encode the facility and priority. You can pass in strings or
  599.         integers - if strings are passed, the facility_names and
  600.         priority_names mapping dictionaries are used to convert them to
  601.         integers.
  602.         """
  603.         if type(facility) == types.StringType:
  604.             facility = self.facility_names[facility]
  605.         if type(priority) == types.StringType:
  606.             priority = self.priority_names[priority]
  607.         return (facility << 3) | priority
  608.  
  609.     def close (self):
  610.         """
  611.         Closes the socket.
  612.         """
  613.         if self.unixsocket:
  614.             self.socket.close()
  615.         logging.Handler.close(self)
  616.  
  617.     def emit(self, record):
  618.         """
  619.         Emit a record.
  620.  
  621.         The record is formatted, and then sent to the syslog server. If
  622.         exception information is present, it is NOT sent to the server.
  623.         """
  624.         msg = self.format(record)
  625.         """
  626.         We need to convert record level to lowercase, maybe this will
  627.         change in the future.
  628.         """
  629.         msg = self.log_format_string % (
  630.             self.encodePriority(self.facility,
  631.                                 string.lower(record.levelname)),
  632.             msg)
  633.         try:
  634.             if self.unixsocket:
  635.                 try:
  636.                     self.socket.send(msg)
  637.                 except socket.error:
  638.                     self._connect_unixsocket(self.address)
  639.                     self.socket.send(msg)
  640.             else:
  641.                 self.socket.sendto(msg, self.address)
  642.         except:
  643.             self.handleError(record)
  644.  
  645. class SMTPHandler(logging.Handler):
  646.     """
  647.     A handler class which sends an SMTP email for each logging event.
  648.     """
  649.     def __init__(self, mailhost, fromaddr, toaddrs, subject):
  650.         """
  651.         Initialize the handler.
  652.  
  653.         Initialize the instance with the from and to addresses and subject
  654.         line of the email. To specify a non-standard SMTP port, use the
  655.         (host, port) tuple format for the mailhost argument.
  656.         """
  657.         logging.Handler.__init__(self)
  658.         if type(mailhost) == types.TupleType:
  659.             host, port = mailhost
  660.             self.mailhost = host
  661.             self.mailport = port
  662.         else:
  663.             self.mailhost = mailhost
  664.             self.mailport = None
  665.         self.fromaddr = fromaddr
  666.         if type(toaddrs) == types.StringType:
  667.             toaddrs = [toaddrs]
  668.         self.toaddrs = toaddrs
  669.         self.subject = subject
  670.  
  671.     def getSubject(self, record):
  672.         """
  673.         Determine the subject for the email.
  674.  
  675.         If you want to specify a subject line which is record-dependent,
  676.         override this method.
  677.         """
  678.         return self.subject
  679.  
  680.     weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
  681.  
  682.     monthname = [None,
  683.                  'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
  684.                  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
  685.  
  686.     def date_time(self):
  687.         """
  688.         Return the current date and time formatted for a MIME header.
  689.         Needed for Python 1.5.2 (no email package available)
  690.         """
  691.         year, month, day, hh, mm, ss, wd, y, z = time.gmtime(time.time())
  692.         s = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
  693.                 self.weekdayname[wd],
  694.                 day, self.monthname[month], year,
  695.                 hh, mm, ss)
  696.         return s
  697.  
  698.     def emit(self, record):
  699.         """
  700.         Emit a record.
  701.  
  702.         Format the record and send it to the specified addressees.
  703.         """
  704.         try:
  705.             import smtplib
  706.             try:
  707.                 from email.Utils import formatdate
  708.             except:
  709.                 formatdate = self.date_time
  710.             port = self.mailport
  711.             if not port:
  712.                 port = smtplib.SMTP_PORT
  713.             smtp = smtplib.SMTP(self.mailhost, port)
  714.             msg = self.format(record)
  715.             msg = "From: %s\r\nTo: %s\r\nSubject: %s\r\nDate: %s\r\n\r\n%s" % (
  716.                             self.fromaddr,
  717.                             string.join(self.toaddrs, ","),
  718.                             self.getSubject(record),
  719.                             formatdate(), msg)
  720.             smtp.sendmail(self.fromaddr, self.toaddrs, msg)
  721.             smtp.quit()
  722.         except:
  723.             self.handleError(record)
  724.  
  725. class NTEventLogHandler(logging.Handler):
  726.     """
  727.     A handler class which sends events to the NT Event Log. Adds a
  728.     registry entry for the specified application name. If no dllname is
  729.     provided, win32service.pyd (which contains some basic message
  730.     placeholders) is used. Note that use of these placeholders will make
  731.     your event logs big, as the entire message source is held in the log.
  732.     If you want slimmer logs, you have to pass in the name of your own DLL
  733.     which contains the message definitions you want to use in the event log.
  734.     """
  735.     def __init__(self, appname, dllname=None, logtype="Application"):
  736.         logging.Handler.__init__(self)
  737.         try:
  738.             import win32evtlogutil, win32evtlog
  739.             self.appname = appname
  740.             self._welu = win32evtlogutil
  741.             if not dllname:
  742.                 dllname = os.path.split(self._welu.__file__)
  743.                 dllname = os.path.split(dllname[0])
  744.                 dllname = os.path.join(dllname[0], r'win32service.pyd')
  745.             self.dllname = dllname
  746.             self.logtype = logtype
  747.             self._welu.AddSourceToRegistry(appname, dllname, logtype)
  748.             self.deftype = win32evtlog.EVENTLOG_ERROR_TYPE
  749.             self.typemap = {
  750.                 logging.DEBUG   : win32evtlog.EVENTLOG_INFORMATION_TYPE,
  751.                 logging.INFO    : win32evtlog.EVENTLOG_INFORMATION_TYPE,
  752.                 logging.WARNING : win32evtlog.EVENTLOG_WARNING_TYPE,
  753.                 logging.ERROR   : win32evtlog.EVENTLOG_ERROR_TYPE,
  754.                 logging.CRITICAL: win32evtlog.EVENTLOG_ERROR_TYPE,
  755.          }
  756.         except ImportError:
  757.             print "The Python Win32 extensions for NT (service, event "\
  758.                         "logging) appear not to be available."
  759.             self._welu = None
  760.  
  761.     def getMessageID(self, record):
  762.         """
  763.         Return the message ID for the event record. If you are using your
  764.         own messages, you could do this by having the msg passed to the
  765.         logger being an ID rather than a formatting string. Then, in here,
  766.         you could use a dictionary lookup to get the message ID. This
  767.         version returns 1, which is the base message ID in win32service.pyd.
  768.         """
  769.         return 1
  770.  
  771.     def getEventCategory(self, record):
  772.         """
  773.         Return the event category for the record.
  774.  
  775.         Override this if you want to specify your own categories. This version
  776.         returns 0.
  777.         """
  778.         return 0
  779.  
  780.     def getEventType(self, record):
  781.         """
  782.         Return the event type for the record.
  783.  
  784.         Override this if you want to specify your own types. This version does
  785.         a mapping using the handler's typemap attribute, which is set up in
  786.         __init__() to a dictionary which contains mappings for DEBUG, INFO,
  787.         WARNING, ERROR and CRITICAL. If you are using your own levels you will
  788.         either need to override this method or place a suitable dictionary in
  789.         the handler's typemap attribute.
  790.         """
  791.         return self.typemap.get(record.levelno, self.deftype)
  792.  
  793.     def emit(self, record):
  794.         """
  795.         Emit a record.
  796.  
  797.         Determine the message ID, event category and event type. Then
  798.         log the message in the NT event log.
  799.         """
  800.         if self._welu:
  801.             try:
  802.                 id = self.getMessageID(record)
  803.                 cat = self.getEventCategory(record)
  804.                 type = self.getEventType(record)
  805.                 msg = self.format(record)
  806.                 self._welu.ReportEvent(self.appname, id, cat, type, [msg])
  807.             except:
  808.                 self.handleError(record)
  809.  
  810.     def close(self):
  811.         """
  812.         Clean up this handler.
  813.  
  814.         You can remove the application name from the registry as a
  815.         source of event log entries. However, if you do this, you will
  816.         not be able to see the events as you intended in the Event Log
  817.         Viewer - it needs to be able to access the registry to get the
  818.         DLL name.
  819.         """
  820.         #self._welu.RemoveSourceFromRegistry(self.appname, self.logtype)
  821.         logging.Handler.close(self)
  822.  
  823. class HTTPHandler(logging.Handler):
  824.     """
  825.     A class which sends records to a Web server, using either GET or
  826.     POST semantics.
  827.     """
  828.     def __init__(self, host, url, method="GET"):
  829.         """
  830.         Initialize the instance with the host, the request URL, and the method
  831.         ("GET" or "POST")
  832.         """
  833.         logging.Handler.__init__(self)
  834.         method = string.upper(method)
  835.         if method not in ["GET", "POST"]:
  836.             raise ValueError, "method must be GET or POST"
  837.         self.host = host
  838.         self.url = url
  839.         self.method = method
  840.  
  841.     def mapLogRecord(self, record):
  842.         """
  843.         Default implementation of mapping the log record into a dict
  844.         that is sent as the CGI data. Overwrite in your class.
  845.         Contributed by Franz  Glasner.
  846.         """
  847.         return record.__dict__
  848.  
  849.     def emit(self, record):
  850.         """
  851.         Emit a record.
  852.  
  853.         Send the record to the Web server as an URL-encoded dictionary
  854.         """
  855.         try:
  856.             import httplib, urllib
  857.             h = httplib.HTTP(self.host)
  858.             url = self.url
  859.             data = urllib.urlencode(self.mapLogRecord(record))
  860.             if self.method == "GET":
  861.                 if (string.find(url, '?') >= 0):
  862.                     sep = '&'
  863.                 else:
  864.                     sep = '?'
  865.                 url = url + "%c%s" % (sep, data)
  866.             h.putrequest(self.method, url)
  867.             if self.method == "POST":
  868.                 h.putheader("Content-length", str(len(data)))
  869.             h.endheaders()
  870.             if self.method == "POST":
  871.                 h.send(data)
  872.             h.getreply()    #can't do anything with the result
  873.         except:
  874.             self.handleError(record)
  875.  
  876. class BufferingHandler(logging.Handler):
  877.     """
  878.   A handler class which buffers logging records in memory. Whenever each
  879.   record is added to the buffer, a check is made to see if the buffer should
  880.   be flushed. If it should, then flush() is expected to do what's needed.
  881.     """
  882.     def __init__(self, capacity):
  883.         """
  884.         Initialize the handler with the buffer size.
  885.         """
  886.         logging.Handler.__init__(self)
  887.         self.capacity = capacity
  888.         self.buffer = []
  889.  
  890.     def shouldFlush(self, record):
  891.         """
  892.         Should the handler flush its buffer?
  893.  
  894.         Returns true if the buffer is up to capacity. This method can be
  895.         overridden to implement custom flushing strategies.
  896.         """
  897.         return (len(self.buffer) >= self.capacity)
  898.  
  899.     def emit(self, record):
  900.         """
  901.         Emit a record.
  902.  
  903.         Append the record. If shouldFlush() tells us to, call flush() to process
  904.         the buffer.
  905.         """
  906.         self.buffer.append(record)
  907.         if self.shouldFlush(record):
  908.             self.flush()
  909.  
  910.     def flush(self):
  911.         """
  912.         Override to implement custom flushing behaviour.
  913.  
  914.         This version just zaps the buffer to empty.
  915.         """
  916.         self.buffer = []
  917.  
  918.     def close(self):
  919.         """
  920.         Close the handler.
  921.  
  922.         This version just flushes and chains to the parent class' close().
  923.         """
  924.         self.flush()
  925.         logging.Handler.close(self)
  926.  
  927. class MemoryHandler(BufferingHandler):
  928.     """
  929.     A handler class which buffers logging records in memory, periodically
  930.     flushing them to a target handler. Flushing occurs whenever the buffer
  931.     is full, or when an event of a certain severity or greater is seen.
  932.     """
  933.     def __init__(self, capacity, flushLevel=logging.ERROR, target=None):
  934.         """
  935.         Initialize the handler with the buffer size, the level at which
  936.         flushing should occur and an optional target.
  937.  
  938.         Note that without a target being set either here or via setTarget(),
  939.         a MemoryHandler is no use to anyone!
  940.         """
  941.         BufferingHandler.__init__(self, capacity)
  942.         self.flushLevel = flushLevel
  943.         self.target = target
  944.  
  945.     def shouldFlush(self, record):
  946.         """
  947.         Check for buffer full or a record at the flushLevel or higher.
  948.         """
  949.         return (len(self.buffer) >= self.capacity) or \
  950.                 (record.levelno >= self.flushLevel)
  951.  
  952.     def setTarget(self, target):
  953.         """
  954.         Set the target handler for this handler.
  955.         """
  956.         self.target = target
  957.  
  958.     def flush(self):
  959.         """
  960.         For a MemoryHandler, flushing means just sending the buffered
  961.         records to the target, if there is one. Override if you want
  962.         different behaviour.
  963.         """
  964.         if self.target:
  965.             for record in self.buffer:
  966.                 self.target.handle(record)
  967.             self.buffer = []
  968.  
  969.     def close(self):
  970.         """
  971.         Flush, set the target to None and lose the buffer.
  972.         """
  973.         self.flush()
  974.         self.target = None
  975.         BufferingHandler.close(self)
  976.